import request from '@/utils/request'
import { tansParams } from '@/utils/ruoyi'

/**
 * 与AI聊天
 * @param {String} prompt 用户输入的提示
 * @param {Array} messages 历史消息
 * @returns {Promise} Promise对象
 */
export function chatWithAI(prompt, messages) {
  // 后端要求两个参数都作为URL参数传递(@RequestParam)
  const params = { 
    prompt: prompt
  };
  
  // 如果有历史消息，添加到参数中
  if (messages && messages.length > 0) {
    params.messages = messages;
  }
  
  return request({
    url: '/manage/ai/chat',
    method: 'post',
    params: params
  })
}

/**
 * 测试AI API连接
 * @returns {Promise} Promise对象
 */
export function testAIConnection() {
  return request({
    url: '/manage/ai/test',
    method: 'get'
  })
}

/**
 * 使用AI生成题目
 * @param {String} chapterId 章节ID
 * @param {Number} questionType 题目类型
 * @param {Number} difficulty 难度等级(1-5)
 * @param {String} prompt 额外提示
 * @param {Number} optionCount 选项数量
 * @returns {Promise} Promise对象
 */
export function generateQuestion(chapterId, questionType, difficulty, prompt, optionCount) {
  return request({
    url: '/manage/ai/generate',
    method: 'post',
    params: {
      chapterId,
      questionType,
      difficulty,
      prompt,
      optionCount
    }
  })
}

/**
 * 优化题目
 * @param {String} questionId 题目ID
 * @param {String} prompt 额外提示
 * @param {Number} difficulty 难度
 * @param {Boolean} processImages 是否处理HTML中的图片，提取并转换为Base64发送
 * @returns {Promise} Promise对象
 */
export function optimizeQuestion(questionId, prompt, difficulty, processImages = true) {
  // 如果不需要处理图片，使用简单的URL参数请求
  if (!processImages) {
  return request({
    url: `/manage/ai/optimize/${questionId}`,
    method: 'post',
    params: {
      prompt,
      difficulty
    }
    });
  }

  // 获取题目详情的请求，封装在Promise中
  return new Promise((resolve, reject) => {
    // 首先获取题目详情
    request({
      url: `/manage/question/${questionId}`,
      method: 'get'
    }).then(response => {
      if (response.code === 200 && response.data) {
        const questionData = response.data;
        
        // 处理可能包含图片的字段
        processHtmlWithImages(
          questionData.questionContent, 
          questionData.answer, 
          "", // 无需标准答案
          questionData.analysis
        ).then(({ 
          processedContent, 
          processedStudentAnswer, 
          processedStandardAnswer, 
          processedAnalysis, 
          imageFiles 
        }) => {
          // 创建FormData
          const formData = new FormData();
          
          // 添加基本参数
          formData.append("questionId", questionId);
          formData.append("prompt", prompt || "");
          if (difficulty) {
            formData.append("difficulty", difficulty);
          }
          
          // 存在图片时，使用FormData方式发送
          if (imageFiles && imageFiles.length > 0) {
            console.log("检测到题目中包含图片，切换为FormData模式发送");
            
            // 添加处理后的HTML内容
            formData.append("questionContent", processedContent);
            formData.append("answer", processedStudentAnswer); // 对应原始答案
            formData.append("analysis", processedAnalysis || '');
            
            // 添加图片文件
            imageFiles.forEach((file, index) => {
              formData.append(`image_${index}`, file);
            });
            
            // 添加图片数量信息
            formData.append("imageCount", imageFiles.length);
            
            // 发送FormData请求
            request({
              url: `/manage/ai/optimize/${questionId}`,
              method: 'post',
              data: formData,
              headers: {
                'Content-Type': 'multipart/form-data'
              }
            }).then(res => resolve(res)).catch(err => reject(err));
          } else {
            // 没有图片，使用普通参数请求
            request({
              url: `/manage/ai/optimize/${questionId}`,
              method: 'post',
              params: {
                prompt,
                difficulty
              }
            }).then(res => resolve(res)).catch(err => reject(err));
          }
        }).catch(err => {
          console.error("处理题目中的图片时出错:", err);
          reject(err);
        });
      } else {
        reject(new Error("获取题目详情失败"));
      }
    }).catch(err => {
      console.error("获取题目详情请求失败:", err);
      reject(err);
    });
  });
}

/**
 * 分析生成的题目
 * @param {Object} questionData 题目数据
 * @returns {Promise} Promise对象
 */
export function analyzeGeneratedQuestion(questionData) {
  return request({
    url: '/manage/ai/analyze/question',
    method: 'post',
    data: questionData
  })
}

/**
 * 生成题目改进建议
 * @param {String} questionId 题目ID
 * @returns {Promise} Promise对象
 */
export function generateQuestionSuggestion(questionId) {
  return request({
    url: `/manage/ai/suggest/improvement/${questionId}`,
    method: 'get'
  })
}

/**
 * 使用AI分析考试数据
 * @param {String} paperId 试卷ID
 * @returns {Promise} Promise对象
 */
export function analyzeExamData(paperId) {
  return request({
    url: `/manage/ai/analyze/exam/${paperId}`,
    method: 'get'
  })
}

/**
 * 获取AI生成的题目建议
 * @param {String} chapterId 章节ID
 * @param {Number} count 建议数量
 * @returns {Promise} Promise对象
 */
export function getQuestionSuggestions(chapterId, count = 5) {
  return request({
    url: '/manage/ai/suggest/questions',
    method: 'get',
    params: {
      chapterId,
      count
    }
  })
}

/**
 * AI辅助批阅简答题
 * 
 * @param {FormData|Object} data 请求数据，可以是FormData或普通对象
 * @param {Boolean} processImages 是否处理HTML中的图片，提取并转换为Base64发送
 * @returns {Promise} 请求的Promise对象
 */
export function assistMarkSubjectiveQuestion(data, processImages = false) {
  // 如果需要处理图片并且传入的是普通对象
  if (processImages && !(data instanceof FormData)) {
    const { questionContent, studentAnswer, standardAnswer, analysis } = data || {};
    // 创建新的FormData
    const formData = new FormData();
    
    // 添加基础字段
    formData.append("questionScore", data.questionScore || 10);
    
    // 处理可能包含图片的字段
    return processHtmlWithImages(questionContent, studentAnswer, standardAnswer, analysis)
      .then(({ processedContent, processedStudentAnswer, processedStandardAnswer, processedAnalysis, imageFiles }) => {
        // 添加处理后的文本
        formData.append("questionContent", processedContent);
        formData.append("studentAnswer", processedStudentAnswer);
        formData.append("standardAnswer", processedStandardAnswer);
        formData.append("analysis", processedAnalysis || '');
        
        // 添加提取的图片文件
        imageFiles.forEach((file, index) => {
          formData.append(`image_${index}`, file);
        });
        
        // 添加图片数量信息
        formData.append("imageCount", imageFiles.length);
        
        // 调用API
        return request({
          url: '/manage/ai/assist-mark',
          method: 'post',
          data: formData,
          headers: {
            'Content-Type': 'multipart/form-data'
          }
        });
      });
  }
  
  // 判断是否是FormData类型
  if (data instanceof FormData) {
    // 如果是FormData，使用post请求并直接传递FormData
    return request({
      url: '/manage/ai/assist-mark',
      method: 'post',
      data: data,
      headers: {
        'Content-Type': 'multipart/form-data'
      }
    });
  } else {
    // 如果是普通对象，使用传统的URL参数方式（保持兼容性）
    const { questionScore, questionContent, studentAnswer, standardAnswer, analysis } = data || {};
    return request({
      url: '/manage/ai/assist-mark',
      method: 'post',
      params: {
        questionScore,
        questionContent,
        studentAnswer,
        standardAnswer,
        analysis
      }
    });
  }
}

/**
 * 处理HTML内容中的图片，将图片提取为文件并替换为标记
 * 
 * @param {String} content 题目内容
 * @param {String} studentAnswer 学生答案
 * @param {String} standardAnswer 标准答案
 * @param {String} analysis 解析
 * @returns {Promise} 处理结果的Promise
 */
function processHtmlWithImages(content, studentAnswer, standardAnswer, analysis) {
  const imageFiles = [];
  const imgTags = [];
  const parser = new DOMParser();
  
  // 创建Promise
  return new Promise((resolve) => {
    // 处理单个HTML内容
    const processHtml = (html, prefix) => {
      if (!html) return '';
      
      const doc = parser.parseFromString(html, 'text/html');
      const images = doc.querySelectorAll('img');
      
      images.forEach((img, index) => {
        const src = img.getAttribute('src');
        if (src) {
          // 如果是base64图片
          if (src.startsWith('data:image/')) {
            // 转换为文件
            const base64 = src.split(',')[1];
            const mimeType = src.split(',')[0].split(':')[1].split(';')[0];
            const extension = mimeType.split('/')[1];
            const fileName = `${prefix}_image_${index}.${extension}`;
            
            // 从base64创建Blob
            const byteCharacters = atob(base64);
            const byteArrays = [];
            for (let i = 0; i < byteCharacters.length; i++) {
              byteArrays.push(byteCharacters.charCodeAt(i));
            }
            const byteArray = new Uint8Array(byteArrays);
            const blob = new Blob([byteArray], { type: mimeType });
            
            // 创建文件
            const file = new File([blob], fileName, { type: mimeType });
            
            // 添加到文件列表
            imageFiles.push(file);
            
            // 替换图片标签
            const placeholder = `[IMAGE:${prefix}_${index}]`;
            img.outerHTML = placeholder;
            imgTags.push({ placeholder, originalSrc: src });
          }
          // 如果是外部URL，可以考虑添加代码来获取这些图片
          // 这里暂时不处理外部URL的图片
        }
      });
      
      return doc.body.innerHTML;
    };
    
    // 处理各部分内容
    const processedContent = processHtml(content, 'content');
    const processedStudentAnswer = processHtml(studentAnswer, 'student');
    const processedStandardAnswer = processHtml(standardAnswer, 'standard');
    const processedAnalysis = processHtml(analysis, 'analysis');
    
    // 返回处理结果
    resolve({
      processedContent,
      processedStudentAnswer,
      processedStandardAnswer,
      processedAnalysis,
      imageFiles,
      imgTags
    });
  });
}

/**
 * AI聊天时支持图片传输
 * @param {String} prompt 提示词
 * @param {Array} messages 历史消息
 * @param {Array|FileList} imageFiles 图片文件列表
 * @returns {Promise} Promise对象
 */
export function chatWithAIAndImages(prompt, messages, imageFiles) {
  const formData = new FormData();
  formData.append('prompt', prompt);
  
  // 添加历史消息
  if (messages && messages.length) {
    messages.forEach((message, index) => {
      formData.append(`messages[${index}]`, message);
    });
  }
  
  // 添加图片文件
  if (imageFiles && imageFiles.length) {
    Array.from(imageFiles).forEach((file, index) => {
      formData.append(`image_${index}`, file);
    });
    formData.append('imageCount', imageFiles.length);
  }
  
  return request({
    url: '/manage/ai/chat',
    method: 'post',
    data: formData,
    headers: {
      'Content-Type': 'multipart/form-data'
    }
  });
}

/**
 * AI生成评语
 * @param {String} prompt 提示
 * @returns {Promise} Promise对象
 */
export function generateMarkComment(prompt) {
  return request({
    url: '/manage/ai/generate-comment',
    method: 'post',
    params: {
      prompt
    }
  })
} 